package com.thread.test20190330.part1.createstartthread03;

/**
 *
 * 创建并启动线程
 *
 *
 * @Description: CreateStartThread
 * @author: conceit
 * @Date: 2019/3/30 17:06
 */
public class CreateStartThread {

    /**
     *
     * jvm启动应用时会运行应用的main线程，同时还有其他的gc，singleDispatcher等线程
     * main线程是非守护线程，是应用的入口
     *
     * 运行jps查看本机jvm进程
     * jps是用于查看有权访问的hotspot虚拟机的进程. 当未指定hostid时，默认查看本机jvm进程
     *
     * 运行jconsole查看性能监控(可用管理员运行)
     *
     *
     * @Description: main
     * @params [args]
     * @author: conceit
     * @return: void
     * @Date: 2019/3/30 17:29
     */
    public static void main(String[] args) throws Exception {
        //singleMainThread();
        //multiThread();
        multiThread2();
    }


    /**
     * main函数直接运行
     * 单线程会进行堵塞
     * @throws InterruptedException
     */
    private static void singleMainThread() throws InterruptedException {
        for(int i=0;i<100;i++){
            System.out.println("i-->"+i);
        }

        for(int j=0;j<100;j++){
            System.out.println("j-->"+j);
        }

        //Thread.sleep(1000*60L);
    }

    /**
     *
     * 多线程运行
     * 运行jconsole查看线程运行状态
     *
     * @Description: multiThread
     * @params []
     * @author: conceit
     * @return: void
     * @Date: 2019/3/30 18:28
     */
    public static void multiThread(){

        Thread t1=new Thread("t1 Thread"){
            @Override
            public void run(){
                for (int i = 0; i < 100; i++) {
                    System.out.println("t1-->"+i);
                    try {
                        Thread.sleep(1000*1L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t1.start();

        Thread t2=new Thread("t2 Thread"){
            @Override
            public void run(){
                for (int i = 0; i < 100; i++) {
                    System.out.println("t2-->"+i);
                    try {
                        Thread.sleep(1000*1L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t2.start();

    }

    /**
     * Thread 本身实现了 Runnable接口
     * 子类只使用唯一的一次，这个时候定义的子类是有些多余了，所以就可以利用内部类的形式来解决此问题
     * Thread implements Runnable
     */
    public static void multiThread2(){
        Thread t1=new Thread(new Runnable() {
            //匿名内部类
            @Override
            public void run() {
                System.out.println("thread1 start .... ");
            }
        });
        t1.setName("t1");
        t1.start();

        Thread t2=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("runnable");
            }
        })
        {
            public void run(){
                System.out.println("sub");
            }
        };
        t2.setName("t2");
        t2.start();
    }

    public static void multiThread3(){
        new Thread(()-> {
            for(int i = 1 ; i<100 ; i++){
                System.out.println("It is a lambda function!");
            }

        }).start();
    }






}
